package com.hilinos.common.util;

import java.util.Random;
import java.util.UUID;

/**
 * 随机数、字符工具包
 *
 * @author qhl
 */
public class RandomUtils {

    private static final Random RANDOM = new Random();
    private static final char[] RANDOM_CHARS = "1234567890qwertyuiopasdfghjklzxcvbnmQWERTYUIOPASDFGHJKLZXCVBNM".toCharArray();

    /**
     * 由于Random不是线程安全的类，因此加上锁
     */
    private static final Object LOCK = new Object();

    /**
     * 默认随机字符串长度
     */
    private static final int DEFAULT_RANDOM_LENGTH = 6;

    /**
     * 生成的随机字符串，统一用一个StringBuilder装，减少对象创建和系统GC
     */
    private static final StringBuilder RANDOM_STR = new StringBuilder();

    /**
     * 生成不重复随机字符串
     * 生成规则：毫秒时间戳 + UUID
     *
     * @return
     */
    public static String getABSRandomString() {
        synchronized (LOCK) {
            try {
                RANDOM_STR.delete(0, RANDOM_STR.length());
                RANDOM_STR.append(System.currentTimeMillis()).append(UUID.randomUUID().toString().replace("-", ""));
                return RANDOM_STR.toString();
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                RANDOM_STR.delete(0, RANDOM_STR.length());
            }
        }
        return null;
    }

    /**
     * 生成随机字符串，默认字符串为 0-9,a-z,A-z
     *
     * @return 默认返回6为随机字符串
     */
    public static String genRandomStr() {
        synchronized (LOCK) {
            return genRandomStr(DEFAULT_RANDOM_LENGTH, RANDOM_CHARS);
        }
    }

    /**
     * 生成随机字符串，默认字符串为 0-9,a-z,A-z
     *
     * @param bit 生成字符串位数,如果小于等于0，则默认返回6为随机字符串
     * @return
     */
    public static String genRandomStr(int bit) {
        return genRandomStr(bit, RANDOM_CHARS);
    }


    /**
     * 生成随机字符串，默认字符串为 0-9,a-z,A-z
     *
     * @param bit
     * @param randomChars 生成的随机字符会从这个集合里获取，如果集合为空，则会在默认集合里获取
     * @return
     */
    public static String genRandomStr(int bit, char[] randomChars) {

        synchronized (LOCK) {
            if (randomChars == null) {
                randomChars = RANDOM_CHARS;
            }
            try {
                if (bit <= 0) {
                    bit = DEFAULT_RANDOM_LENGTH;
                }
                for (int i = 0; i < bit; i++) {
                    RANDOM_STR.append(randomChars[genRandomInt(randomChars.length)]);
                }
                return RANDOM_STR.toString();
            } finally {
                RANDOM_STR.delete(0, RANDOM_CHARS.length);
            }
        }
    }

    /**
     * 生成随机数，只会大于等于0的整数
     *
     * @return
     */
    public static int genRandomInt() {
        return genRandomInt(Integer.MAX_VALUE);
    }

    /**
     * 生成随机数[半闭半开区间)，生成大于等于0并且小于max的整数
     *
     * @return
     */
    public static int genRandomInt(int max) {
        return RANDOM.nextInt(max);
    }

    /**
     * 生成随机数[半闭半开区间)，生成大于等于min并且小于min+range的整数
     *
     * @return
     */
    public static int genRandomInt(int min, int range) {
        return min + genRandomInt(range);
    }

}
